package com.yidu.hbatsft.service.impl;

import com.github.pagehelper.PageHelper;
import com.yidu.hbatsft.dao.AtsSchemeAthleteMapper;
import com.yidu.hbatsft.dao.AtsSchemeAuditMapper;
import com.yidu.hbatsft.dao.AtsSchemeExpertMapper;
import com.yidu.hbatsft.dao.AtsSchemeMapper;
import com.yidu.hbatsft.domain.AtsScheme;
import com.yidu.hbatsft.domain.AtsSchemeExpert;
import com.yidu.hbatsft.service.MentalityAtsSchemeService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Iterator;
import java.util.List;
/**
  *@ClassName MentalityAtsSchemeServiceImpl
  *@Description 方案service实现类
  *@Author 肖瑜
  *@Date 2020/1/9 10:08
  *@Version 1.0
**/
@Service
public class MentalityAtsSchemeServiceImpl implements MentalityAtsSchemeService {
    //方案mapper
    @Resource
    AtsSchemeMapper atsSchemeMapper;
    //方案对应的运动员mapper
    @Resource
    AtsSchemeAthleteMapper atsSchemeAthleteMapper;
    //专家咨询mapper
    @Resource
    AtsSchemeExpertMapper atsSchemeExpertMapper;
    //方案审核mapper
    @Resource
    AtsSchemeAuditMapper atsSchemeAuditMapper;

    /**
     * 查询所有方案
     * @param pageNum 页数
     * @param pageSize 条数
     * @param atsScheme 方案对象
     * @return list 集合
     */
    @Override
    public List<AtsScheme> findAll(Integer pageNum, Integer pageSize,AtsScheme atsScheme) {
        //开始分页
        PageHelper.startPage(pageNum,pageSize);
        //调用查询所有方案
        List all = atsSchemeMapper.findAll(atsScheme);
        //循环
        for (Iterator iterator = all.iterator(); iterator.hasNext(); ) {
            AtsScheme ats =  (AtsScheme)iterator.next();
            //调用根据方案ID查询专家咨询方法
            AtsSchemeExpert expert = atsSchemeExpertMapper.selectByschemeKey(ats.getSchemeId());
            //判断专家咨询为空或者审核状态为空
            if(expert==null||"".equals(expert.getAuditState())||expert.getAuditState()==null){
                //设置方案状态为0
                ats.setAuditState(0);
            }else{
                //设置方案状态为专家咨询状态
                ats.setAuditState(Integer.valueOf(expert.getAuditState()));
            }
        }
        //返回方案集合
        return all;
    }

    /**
     * 查询所有
     * @return list 集合
     */
    @Override
    public List<AtsScheme> findAllList() {
        return atsSchemeMapper.findAllList();
    }

    /**
     * 根据方案ID查询
     * @param id 方案ID
     * @return AtsScheme 方案对象
     */
    @Override
    public AtsScheme findAllById(Integer id) {
        return atsSchemeMapper.findAllById(id);
    }

    /**
     * 统计方案条数
     * @param atsScheme 方案对象
     * @return long 行数
     */
    @Override
    public Long count(AtsScheme atsScheme) {
        return atsSchemeMapper.count(atsScheme);
    }

    /**
     * 新增方案
     * @param record 方案对象
     * @return int 行数
     */
    @Override
    public int insertSelective(AtsScheme record) {
        return atsSchemeMapper.insertSelective(record);
    }

    /**
     * 根据方案ID查询
     * @param schemeId 方案ID
     * @return AtsScheme 方案对象
     */
    @Override
    public AtsScheme selectByPrimaryKey(Integer schemeId) {
        return atsSchemeMapper.selectByPrimaryKey(schemeId);
    }

    /**
     * 修改方案
     * @param record 方案对象
     * @return int 行数
     */
    @Override
    public int updateByPrimaryKeySelective(AtsScheme record) {
        return atsSchemeMapper.updateByPrimaryKeySelective(record);
    }

    /**
     * 根据方案ID修改是否有效
     * @param id 方案ID
     * @return int 行数
     */
    @Override
    public int updateIsvaById(Integer id) {
        //调用修改方案是否有效方法
        int rows = atsSchemeMapper.updatestate(id);
        //调用修改方案对应的运动员的是否有效方法
        atsSchemeAthleteMapper.updatestate(id);
        //调用修改专家咨询的是否有效方法
        atsSchemeExpertMapper.updatestate(id);
        //调用修改审核的是否有效方法
        atsSchemeAuditMapper.updatestate(String.valueOf(id));
        //返回行数
        return rows;
    }

    /**
     * 查询所有专家的方案
     * @param pageNum 页数
     * @param pageSize 条数
     * @param atsScheme 方案对象
     * @return list 集合
     */
    @Override
    public List<AtsScheme> selectExpert(Integer pageNum, Integer pageSize,AtsScheme atsScheme) {
        //开始分页
        PageHelper.startPage(pageNum,pageSize);
        return atsSchemeMapper.selectExpert(atsScheme);
    }

    /**
     * 统计所有专家的方案条数
     * @param atsScheme 方案对象
     * @return long 行数
     */
    @Override
    public Long countExpert(AtsScheme atsScheme) {
        return atsSchemeMapper.countExpert(atsScheme);
    }

    /**
     * 查询所有领导审核的方案
     * @param pageNum 页数
     * @param pageSize 条数
     * @param atsScheme 方案对象
     * @return list 集合
     */
    @Override
    public List<AtsScheme> selectAudit(Integer pageNum, Integer pageSize,AtsScheme atsScheme) {
        //开始分页
        PageHelper.startPage(pageNum,pageSize);
        return atsSchemeMapper.selectAudit(atsScheme);
    }

    /**
     * 统计所有领导审核的方案条数
     * @param atsScheme 方案对象
     * @return long 条数
     */
    @Override
    public Long countAudit(AtsScheme atsScheme) {
        return atsSchemeMapper.countAudit(atsScheme);
    }

    /**
     * 查询所有运动员的方案
     * @param atsScheme 方案对象
     * @return list 集合
     */
    @Override
    public List<AtsScheme> selectAthlete(Integer pageNum, Integer pageSize,AtsScheme atsScheme) {
        //开始分页
        PageHelper.startPage(pageNum,pageSize);
        return atsSchemeMapper.selectAthlete(atsScheme);
    }

    /**
     * 统计所有运动员的方案条数
     * @param atsScheme 方案对象
     * @return long 行数
     */
    @Override
    public Long countAthlete(AtsScheme atsScheme) {
        return atsSchemeMapper.countAthlete(atsScheme);
    }


}
